home *** CD-ROM | disk | FTP | other *** search
/ Aminet 39 / Aminet 39 (2000)(Schatztruhe)[!][Oct 2000].iso / Aminet / comm / misc / Twiny.lha / Amiga / Source / Twiny.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-15  |  5.0 KB  |  198 lines
  1. /// Includes
  2. #include <devices/input.h>
  3. #include <devices/inputevent.h>
  4. #include <netdb.h>
  5. #include <netinet/in.h>
  6. #include <sys/ioctl.h>
  7. #include <string.h>
  8.  
  9. #include <proto/exec.h>
  10. #include <proto/dos.h>
  11. #include <clib/socket_protos.h>
  12. #include <pragmas/socket_pragmas.h>
  13. ///
  14. /// Prototypes
  15. void HandleConnection( int peer );
  16. BOOL RecvIEvent( int peer, struct InputEvent *event );
  17. int NetRecvT( int sock, char *buffer, int len, int flags, int timeout );
  18. ///
  19. /// Macros
  20. #define NET_TIMEOUT                     (-2)
  21. ///
  22. /// Data
  23. static char Version[] = "$VER: Twiny 1.1 (14.8.00) by Simone Tellini";
  24.  
  25. struct Library *SocketBase;
  26. ///
  27.  
  28. /// main
  29. int main( int argc, char *argv[] )
  30. {
  31.     if( SocketBase = OpenLibrary( "bsdsocket.library", 0 )) {
  32.         int sock;
  33.  
  34.         sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
  35.  
  36.         if( sock >= 0 ) {
  37.             struct sockaddr_in  addr;
  38.  
  39.             memset( &addr, 0, sizeof( addr ));
  40.  
  41.             addr.sin_family = AF_INET;
  42.             addr.sin_port   = htons( 1414 );
  43.  
  44.             if( bind( sock, (struct sockaddr *)&addr, sizeof( addr )) >= 0 ) {
  45.                 ULONG   sigs = SIGBREAKF_CTRL_C;
  46.  
  47.                 listen( sock, 1 );
  48.  
  49.                 for(;;) {
  50.                     fd_set  fds;
  51.  
  52.                     FD_ZERO( &fds );
  53.                     FD_SET( sock, &fds );
  54.  
  55.                     Printf( "waiting for a connection...\n" );
  56.  
  57.                     if( WaitSelect( sock + 1, &fds, NULL, NULL, NULL, &sigs ) <= 0 )
  58.                         break;
  59.  
  60.                     if( FD_ISSET( sock, &fds )) {
  61.                         int     peer;
  62.                         LONG    len = sizeof( &addr );
  63.  
  64.                         if(( peer = accept( sock, (struct sockaddr *)&addr, &len )) >= 0 ) {
  65.  
  66.                             HandleConnection( peer );
  67.  
  68.                             CloseSocket( peer );
  69.  
  70.                         } else
  71.                             Printf( "Incoming connection couldn't be accepted!\n" );
  72.                     }
  73.                 }
  74.  
  75.             } else
  76.                 Printf( "Cannot bind()!\n" );
  77.  
  78.             CloseSocket( sock );
  79.  
  80.         } else
  81.             Printf( "Can't create a socket!\n" );
  82.  
  83.         CloseLibrary( SocketBase );
  84.  
  85.     } else
  86.         Printf( "Can't open socket.library!\n" );
  87.  
  88.     return( 0 );
  89. }
  90. ///
  91. /// HandleConnection
  92. void HandleConnection( int peer )
  93. {
  94.     struct MsgPort *Port;
  95.  
  96.     if( Port = CreateMsgPort() ) {
  97.         struct IOStdReq *req;
  98.  
  99.         if( req = ( struct IOStdReq * )CreateIORequest( Port, sizeof( struct IOStdReq ))) {
  100.  
  101.             if( !OpenDevice( "input.device", 0, ( struct IORequest * )req, 0L )) {
  102.  
  103.                 SetTaskPri( FindTask( NULL ), 19 );
  104.  
  105.                 for(;;) {
  106.                     fd_set              fds;
  107.                     struct InputEvent   event;
  108.                     ULONG               sigs = SIGBREAKF_CTRL_C;
  109.  
  110.                     memset( &event, 0, sizeof( event ));
  111.  
  112.                     FD_ZERO( &fds );
  113.                     FD_SET( peer, &fds );
  114.  
  115.                     if( WaitSelect( peer + 1, &fds, NULL, NULL, NULL, &sigs ) <= 0 )
  116.                         break;
  117.  
  118.                     if( FD_ISSET( peer, &fds ) && ( recv( peer, (char *)&sigs, 1, MSG_PEEK ) <= 0 )) {
  119.                         Printf( "remote connection closed\n" );
  120.                         break;
  121.                     }
  122.  
  123.                     if( FD_ISSET( peer, &fds ) && RecvIEvent( peer, &event )) {
  124.  
  125.                         req->io_Command = IND_WRITEEVENT;
  126.                         req->io_Length  = sizeof( struct InputEvent );
  127.                         req->io_Data    = &event;
  128.  
  129.                         DoIO(( struct IORequest * )req );
  130.                     }
  131.                 }               
  132.  
  133.                 SetTaskPri( FindTask( NULL ), 0 );
  134.  
  135.                 CloseDevice(( struct IORequest * )req );
  136.             }
  137.  
  138.             DeleteIORequest( req );
  139.         }
  140.  
  141.         DeleteMsgPort( Port );
  142.     }
  143. }
  144. ///
  145. /// RecvIEvent
  146. BOOL RecvIEvent( int peer, struct InputEvent *event )
  147. {
  148.     BOOL    ok;
  149.     struct {
  150.         char    Class;
  151.         char    Subclass;
  152.         short   Code;
  153.         short   Qual;
  154.         short   MX;
  155.         short   MY;
  156.     }       msg;
  157.  
  158.     ok = NetRecvT( peer, (char *)&msg, sizeof( msg ), 0, 2 ) == sizeof( msg );
  159.  
  160.     if( ok ) {
  161.  
  162.         event->ie_Class     = msg.Class;
  163.         event->ie_SubClass  = msg.Subclass;
  164.         event->ie_Code      = ntohs( msg.Code );
  165.         event->ie_Qualifier = ntohs( msg.Qual );
  166.         event->ie_X         = ntohs( msg.MX   );
  167.         event->ie_Y         = ntohs( msg.MY   );
  168.     }
  169.  
  170.     return( ok );
  171. }
  172. ///
  173. /// NetRecvT
  174. int NetRecvT( int sock, char *buffer, int len, int flags, int timeout )
  175. {
  176.     struct timeval  to;
  177.     fd_set          fds;
  178.     int             ret;
  179.     ULONG           sigs = SIGBREAKF_CTRL_C;
  180.  
  181.     memset( &to, 0, sizeof( to ));
  182.  
  183.     to.tv_sec = timeout;
  184.  
  185.     FD_ZERO( &fds );
  186.     FD_SET( sock, &fds );
  187.  
  188.     ret = WaitSelect( sock + 1, &fds, NULL, NULL, &to, &sigs );
  189.  
  190.     if(( ret > 0 ) && FD_ISSET( sock, &fds ))
  191.         ret = recv( sock, buffer, len, flags );
  192.     else if( ret == 0 )
  193.         ret = NET_TIMEOUT;
  194.  
  195.     return( ret );
  196. }
  197. ///
  198.